# -*- coding: latin-1 -*-
#!/usr/bin/env python
'''
Created on 03/10/2011

@author: nmedina
'''

import sys
import xml.dom.minidom 
import Excepciones
import Errores

#------------------------------------------------------------------------------
#------ XML ---#FFFFFF#C64401--------------------------------------------------
#------------------------------------------------------------------------------
# Autor: Nestor ---------------------------------------------------------------
#------------------------------------------------------------------------------

from xml.dom.minidom import parse, parseString

class XML:
    """Clase XML: XML(CadenaXML)
    Metodos:
        - ReemplazarCaracteres
        - ReemplazarCaracteresDict
        - TraerNodoXEtiqueta
        - TraerXML
        """

#------------------------------------------------------------------------------

    def __init__(self, CadenaXML):
        self.CadenaOriginal = CadenaXML
        self.CadenaXML = parseString(CadenaXML)
        self.CadenaXMLReemplazada = parseString(self.ReemplazarCaracteres(self.CadenaOriginal))

#------------------------------------------------------------------------------

    def ReemplazarCaracteres(self, cadena):
        """ Metodo Reemplazar Caracteres: XML.ReemplazarCaracteres(Cadena) String """
        cadena = cadena.replace("&amp;", "&").replace("&lt;", "<")
        cadena = cadena.replace("&quot;", "\"").replace("&gt;", ">")
        return cadena

#------------------------------------------------------------------------------

    def ReemplazarCaracteresDict(self,cadena):
        """ Metodo Reemplazar Caracteres: XML.ReemplazarCaracteresDict(Cadena) String """
        cadena = cadena.replace("&apos;", "'")
        return cadena

#------------------------------------------------------------------------------

    def TraerNodoXEtiqueta(self, EtiquetaNodo):
        """ Metodo Traer valor del nodo: XML.TraerNodoXEtiqueta(EtiquetaNodo) String """
        self.EtiquetaNodo = EtiquetaNodo
        self.__Nodo = self.CadenaXML.getElementsByTagName(self.EtiquetaNodo)[0]
        return self.__Nodo.childNodes[0].nodeValue

#------------------------------------------------------------------------------
    def ExisteNodo(self,nombre):
        return self.CadenaXML.hasAttribute(nombre)
    def TraerXML(self):
        """ Metodo Traer XML: XML.TraerXML() String"""
        return self.CadenaXMLReemplazada.toxml('latin-1')
    
#******************************************************************************

#------------------------------------------------------------------------------
#------ Servicios Web---#FFFFFF#C64401-----------------------------------------
#------------------------------------------------------------------------------
# Autor: Nestor ---------------------------------------------------------------
#------------------------------------------------------------------------------

import httplib
import urllib2
import cgi
SERVIDOR_ASP = 1
SERVIDOR_WEB2PY = 2
class WebService:
    """Clase Web Service: WebService(UrlServidor, Host, [UrlProxy])
    Metodos:
        - Enviar
        - soap
        - LeerDatos
        
    Atributos:                
        - Coneccion: Coneccion al Web Service
        - ErrorNumero: Numero de Error (0 por defecto)
        - ErrorDescripcion: Descripcion del Error (OK por defecto)
        - Encabezado: El Encabezado de la respuesta
        - Respuesta: El XML de respuesta del Web Service
        - TipoRespuesta: El tipo de respuesta que se le pidio
        """

#------------------------------------------------------------------------------        
               
    def __init__(self
                 ,UrlServidor
                 ,Host
                 ,UrlProxy = None
                 ,TipoServidor = SERVIDOR_ASP
                 ,Reintentos = 1):
        if UrlProxy != None:
            self.__ConProxy = True
        else:
            self.__ConProxy = False
        self.__ErrorDescripcion = ""
        self.__ErrorNumero = 0
        self.__Proxy = UrlProxy
        self.__ServidorWeb = UrlServidor
        self.__HostServidor = Host
        self.__TipoServidor = TipoServidor
        self.__Reintentos = Reintentos
    def __ArmarSoap(self):
        try:
            if self.__TipoServidor == SERVIDOR_ASP:
                self.__soap = '''<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<%s xmlns="http://%s/">''' % (self.__Metodo, self.__NombreWebService)
            
                if len(self.__Params) > 0:
                    #Le agrego al Encabezado los parametros, si le llegaron al metodo
                    for ParamsKeys in self.__Params.keys():
                        #Si llegase a tirar UnicodeDecodeError linea 223, es porque esta mal instalado
                        #el wxPython, leer O:\Python\Librerias\wxPython\Instalar.txt y no tocar el codigo
                        
                        self.__RespuestaUnicode = unicode(self.__Params.get(ParamsKeys)[1],'latin-1')
                        self.__soap = self.__soap + '''<%s>''' % self.__Params.get(ParamsKeys)[0]
                        self.__soap = self.__soap + '''%s''' % self.__RespuestaUnicode.encode('utf-8')
                        self.__soap = self.__soap + '''</%s>''' % self.__Params.get(ParamsKeys)[0]
                    self.__soap = self.__soap + '''</%s>
</soap:Body>
</soap:Envelope>''' % self.__Metodo
                return True
            elif self.__TipoServidor == SERVIDOR_WEB2PY:
                self.__soap = '''<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<%s xmlns="http://%s/">''' % (self.__Metodo, self.__ServidorWeb)
                if len(self.__Params) > 0:
                    #Le agrego al Encabezado los parametros, si le llegaron al metodo
                    for ParamsKeys in self.__Params.keys():
                        #Si llegase a tirar UnicodeDecodeError linea 223, es porque esta mal instalado
                        #el wxPython, leer O:\Python\Librerias\wxPython\Instalar.txt y no tocar el codigo
                        
                        self.__RespuestaUnicode = unicode(self.__Params.get(ParamsKeys)[1],'latin-1')
                        self.__soap = self.__soap + '''<%s>''' % self.__Params.get(ParamsKeys)[0]
                        self.__soap = self.__soap + '''%s''' % self.__RespuestaUnicode.encode('utf-8')
                        self.__soap = self.__soap + '''</%s>''' % self.__Params.get(ParamsKeys)[0]
                    self.__soap = self.__soap + '''</%s>
</soap:Body>
</soap:Envelope>''' % self.__Metodo
                return True
                
        except:
            error = sys.exc_info()[:2]
            raise Excepciones.Genericas.WebService_Error(
                                "Error al generar xml soap"
                                , str(error[0])
                                , str(error[1]))
    def __ArmarHead(self):
        try:
            if self.__TipoServidor == SERVIDOR_ASP: 
                self.__Head = {'content-type':'text/xml; charset=utf-8','Host': self.__HostServidor,
                             'Content-Length':str(len(self.__soap)),
                             'SOAPAction': 'http://' + self.__NombreWebService + '/' + self.__Metodo
                             }
                return True
            elif self.__TipoServidor == SERVIDOR_WEB2PY: 
                self.__Head = {'content-type':'text/xml; charset=utf-8','Host': self.__HostServidor,
                             'Content-Length':str(len(self.__soap)),
                             'SOAPAction': 'http://' + self.__NombreWebService + '/' + self.__Metodo
                             }
                return True
        except:
            error = sys.exc_info()[:2]
            raise Excepciones.Genericas.WebService_Error(
                        "Error al crear head soap"
                        ,str(error[0])
                        , str(error[1]))
            
    def Enviar(self
               ,Metodo
               ,NombreWebService
               ,Parametros
               ,TipoRespuesta = 'Python'
               ):
        
        self.__Metodo = Metodo
        self.__NombreWebService = NombreWebService
        self.__TipoRespuesta = TipoRespuesta
        self.__Params = Parametros
        if self.__ArmarSoap()== True:
            pass
        else:
            return False
                
        if self.__ArmarHead()== True:
            pass
        else:
            return False

        if self.__Enviar()== True:
            pass
        else:
            return False
        
        if self.__BuscarErrores()== False:
            pass
        else:
            return False
        
        if self.__CrearRecordset()== True:
            pass
        else:
            return False
        
        return True

#------------------------------------------------------------------------------
    def __Enviar(self):
        try:
            self.__CantidadRepeticiones = 0
            self.__badrequest = False
            __respuesta = False
            while __respuesta == False and int(self.__CantidadRepeticiones) < int(self.__Reintentos):
                __respuesta = self.__Execute()
            if __respuesta == False and self.__CantidadRepeticiones == self.__Reintentos:
                raise urllib2.URLError , "Cantidad de reintentos agotados, Time Out"
            
            return True
        except:
            error = sys.exc_info()[:2]
            raise Excepciones.Genericas.WebService_Error(
                                               "Error al ejecutar WebService"
                                               , str(error[0])
                                               , str(error[1]))
    def __Execute(self):
        try:
            if self.__ConProxy == True:
                proxy = urllib2.ProxyHandler({"http":self.__Proxy})
                opener = urllib2.build_opener(proxy,urllib2.HTTPHandler)
                urllib2.install_opener(opener)
                if self.__TipoServidor == SERVIDOR_ASP:
                    Apertura = urllib2.Request(self.__ServidorWeb,self.__soap,self.__Head,"POST")
                    self.__RespuestaPrimaria = urllib2.urlopen(Apertura)
                    self.__RespuestaSinParsear = self.__RespuestaPrimaria.read()
                    return True
                elif self.__TipoServidor == SERVIDOR_WEB2PY:
                    Apertura = urllib2.Request(url = self.__ServidorWeb
                                                    ,data = self.__soap
                                                    ,origin_req_host = "POST")
                    self.__RespuestaPrimaria = urllib2.urlopen(Apertura)
                    self.__RespuestaSinParsear = self.__RespuestaPrimaria.read()  
                    return True         
            else:
                 Apertura = urllib2.Request(self.__ServidorWeb,self.__soap,self.__Head,"POST")
                 self.__RespuestaPrimaria = urllib2.urlopen(Apertura)
                 self.__RespuestaSinParsear = self.__RespuestaPrimaria.read()
                 return True
        except urllib2.HTTPError , e :
            error = sys.exc_info()[:2]
            if int(e.code)== 408:
                self.__CantidadRepeticiones = self.__CantidadRepeticiones + 1
                return False
            else:
                raise Excepciones.Genericas.WebService_Error(
                            ""
                            , "urllib2.HTTPError"
                            , error[1])
        except:
            error = sys.exc_info()[:2]
            return False
    def __BuscarErrores(self):
        try:
            self.__RespuestaXML = XML(self.__RespuestaSinParsear)
            self.__cadena = self.__RespuestaXML.TraerNodoXEtiqueta(self.__Metodo + 'Result')
            if self.__TipoServidor == SERVIDOR_ASP:   
                Error = XML(self.__cadena.encode('utf-8'))
                ResultError = Error.TraerNodoXEtiqueta('Error')
                raise Excepciones.Genericas.WebServiceError(ResultError)
            if self.__TipoServidor == SERVIDOR_WEB2PY:
                xmlError = self.__RespuestaXML.TraerNodoXEtiqueta('Fault')
                xmldescripcion = XML(xmlError.encode('utf-8'))
                tipoerror = xmldescripcion.TraerNodoXEtiqueta("faultcode")
                deserror = xmldescripcion.TraerNodoXEtiqueta("faultstring")
                raise Excepciones.Genericas.WebServiceError("""""" + str(tipoerror) + """
"""  + str(deserror) )
               
        except IndexError:
            return False
        except:
            error = sys.exc_info()[:2]
            raise Excepciones.Genericas.WebService_Error(
                            "Error al buscar Errores"
                            , str(error[0])
                            , str(error[1]))
            
    def __CrearRecordset(self):
        try:
            recorset = XML(self.__cadena.encode('utf-8'))
            self._recordset = None
            if self.__TipoServidor == SERVIDOR_ASP:
                record = recorset.TraerNodoXEtiqueta('Recorset')
                self.__recordset = RecordSet(record.encode("latin-1"))
                return True
            elif self.__TipoServidor == SERVIDOR_WEB2PY:
                self.__recordset = RecordSet(self.__cadena.encode("latin-1"))
                return True
        except:
            error = sys.exc_info()[:2]
            raise Excepciones.Genericas.WebService_Error(
                    "Error al crear recordset"
                    , str(error[0])
                    , str(error[0]))
    def Soap(self):
        """ Metodo Soap: WebService.soap() String """
        return str(self.soap)
#    def Enviar(self
#               ,Metodo
#               ,NombreWebService
#               ,Parametros
#               ,TipoRespuesta = 'Python'
#               ):
#        try:
#            self.__Metodo = Metodo
#            self.__NombreWebService = NombreWebService
#            self.__TipoRespuesta = TipoRespuesta
#            self.__Params = Parametros
#            try:
#                if self.__ArmarSoap()== True:
#                    pass
#                else:
#                    return False
#                
#                if self.__ArmarHead()== True:
#                    pass
#                else:
#                    return False
##                try:
##                    if self.ConProxy == True:
##                        proxy = urllib2.ProxyHandler({"http":self.Proxy})
##                        opener = urllib2.build_opener(proxy,urllib2.HTTPHandler)
##                        urllib2.install_opener(opener)
##                        if self.__TipoServidor == SERVIDOR_ASP:
##                            Apertura = urllib2.Request(self.ServidorWeb,self.soap,self.Head,"POST")
##                            self.__RespuestaPrimaria = urllib2.urlopen(Apertura)
##                            self.RespuestaSinParsear = self.__RespuestaPrimaria.read()
##                        elif self.__TipoServidor == SERVIDOR_WEB2PY:
##                            Apertura = urllib2.Request(url = self.ServidorWeb
##                                                       ,data = self.soap
##                                                       ,origin_req_host = "POST")
##                            self.__RespuestaPrimaria = urllib2.urlopen(Apertura)
##                            self.RespuestaSinParsear = self.__RespuestaPrimaria.read()
##                                
##                    else:
##                        Apertura = urllib2.Request(self.ServidorWeb,self.soap,self.Head,"POST")
##                        self.__RespuestaPrimaria = urllib2.urlopen(Apertura)
##                        self.RespuestaSinParsear = self.__RespuestaPrimaria.read()
##                    try:
##                        self.__RespuestaXML = XML(self.RespuestaSinParsear)
##                        cadena = self.__RespuestaXML.TraerNodoXEtiqueta(self.Metodo + 'Result')
##                        if self.__TipoServidor == SERVIDOR_ASP:   
##                            Error = XML(cadena.encode('utf-8'))
##                            recorset = XML(cadena.encode('utf-8'))
##                        
##                        try:
##                            ResultError = Error.TraerNodoXEtiqueta('Error')
##                            self.ErrorNumero = 2104
##                            self.ErrorDescripcion = "Modulo: Funciones\nClase: WebService\nMetodo: Enviar\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Web Service: " + str(self.Metodo) + "\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Nro Error: " + str(self.ErrorNumero) + "\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Descripcion: " + ResultError
##                            return False
##                        except:
##                            try:
##                                self._recordset = None
##                                if self.__TipoServidor == SERVIDOR_ASP:
##                                    record = recorset.TraerNodoXEtiqueta('Recorset')
##                                    self.__recordset = RecordSet(record.encode("latin-1"))
##                                    return True
##                                elif self.__TipoServidor == SERVIDOR_WEB2PY:
##                                    self.__recordset = RecordSet(cadena.encode("latin-1"))
##                                    return True
##                            except:
##                                error = sys.exc_info()[:2]
##                                self.ErrorDescripcion = "Modulo: Funciones\nClase: WebService\nMetodo: Enviar\n"
##                                self.ErrorDescripcion = "Exception: " + str(error[0]) + "\nDescripcion: " + str(error[1])
##                                return False
##                        
##                    except:
##                        if self.__TipoServidor == SERVIDOR_WEB2PY:
##                            xmlError = self.__RespuestaXML.TraerNodoXEtiqueta('Fault')
##                            xmldescripcion = XML(xmlError.encode('utf-8'))
##                            tipoerror = xmldescripcion.TraerNodoXEtiqueta("faultcode")
##                            deserror = xmldescripcion.TraerNodoXEtiqueta("faultstring")
##                            self.ErrorNumero = 2103
##                            self.ErrorDescripcion = "Modulo: Funciones\nClase: WebService\nMetodo: Enviar\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Web Service: " + str(self.Metodo) + "\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Nro Error: " + str(self.ErrorNumero) + "\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Exception: " + str(tipoerror) + "\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Descripcion: " + str(deserror)
##                            return False
##                        else:
##                            error = sys.exc_info()[:2]
##                            self.ErrorNumero = 2103
##                            self.ErrorDescripcion = "Modulo: Funciones\nClase: WebService\nMetodo: Enviar\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Web Service: " + str(self.Metodo) + "\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Nro Error: " + str(self.ErrorNumero) + "\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Exception: " + str(error[0]) + "\n"
##                            self.ErrorDescripcion = self.ErrorDescripcion + "Descripcion: " + str(error[1])
##                            return False
##                    
##                except:
##                    error = sys.exc_info()[:2]
##                    self.ErrorNumero = 2102
##                    self.ErrorDescripcion = "Modulo: Funciones\nClase: WebService\nMetodo: Enviar\n"
##                    self.ErrorDescripcion = self.ErrorDescripcion + "Web Service: " + str(self.Metodo) + "\n"
##                    self.ErrorDescripcion = self.ErrorDescripcion + "Nro Error: " + str(self.ErrorNumero) + "\n"
##                    self.ErrorDescripcion = self.ErrorDescripcion + "Exception: " + str(error[0]) + "\n"
##                    self.ErrorDescripcion = self.ErrorDescripcion + "Descripcion: " + str(error[1])
##                    return False
#            except:
#                error = sys.exc_info()[:2]
#                self.ErrorNumero = 2102
#                self.ErrorDescripcion = "Modulo: Funciones\nClase: WebService\nMetodo: Enviar\n"
#                self.ErrorDescripcion = self.ErrorDescripcion + "Web Service: " + str(self.Metodo) + "\n"
#                self.ErrorDescripcion = self.ErrorDescripcion + "Nro Error: " + str(self.ErrorNumero) + "\n"
#                self.ErrorDescripcion = self.ErrorDescripcion + "Exception: " + str(error[0]) + "\n"
#                self.ErrorDescripcion = self.ErrorDescripcion + "Descripcion: " + str(error[1])
#                return False

##------------------------------------------------------------------------------
#
#    def LeerDatos(self, NombreCampo = ''):
#        """Metodo Leer Datos: WebService.LeerDatos(Mobre del Campo a traer) Lista"""
#        self.__RespuestaXML = XML(self.RespuestaSinParsear)
#        self.NombreCampo = NombreCampo
#        cadena = self.__RespuestaXML.TraerNodoXEtiqueta(self.Metodo + 'Result')
#        self.__RespuestaXMLParseado = XML(cadena.encode('utf-8'))
#        self.RespuestaParseada = self.__RespuestaXMLParseado.TraerNodoXEtiqueta('Recorset')
#
#        try:
#            cadena1 = self.__RespuestaXML.TraerNodoXEtiqueta(self.Metodo + 'Result')
#            self.__RespuestaXMLParseado = XML(cadena.encode('utf-8'))
#            self.RespuestaParseada = self.__RespuestaXMLParseado.TraerNodoXEtiqueta('Recorset')
#            
#            if self.TipoRespuesta == 'Python':
#                if NombreCampo != '':
#                    #todo: try+raise
#                    try:
#                        self.RespuestaObj = Cadena(self.RespuestaParseada)
#                        if self.RespuestaObj.DiccionarioStrALista(NombreCampo) == None:
#                            self.ErrorNumero = self.RespuestaObj.ErrorNumero
#                            self.ErrorDescripcion = self.RespuestaObj.ErrorDescripcion
#                            raise NoExisteKey(NombreCampo)
#                        else:
#                            self.ErrorNumero = self.RespuestaObj.ErrorNumero
#                            self.ErrorDescripcion = self.RespuestaObj.ErrorDescripcion
#                            return self.RespuestaObj.DiccionarioStrALista(NombreCampo)
#                            
#                    except NoExisteKey, e:
#                        self.ErrorNumero = 1104
#                        self.ErrorDescripcion = e.MensajeError()
#                        return None
#                    except:
#                        self.ErrorNumero = 1103
#                        self.ErrorDescripcion = 'Error 1103: Error en la convercion del diccionario'
#                        return self.RespuestaParseada
#                else:
#                    try:
#                        self.RespuestaObj = Cadena(self.RespuestaParseada)
#                        if self.RespuestaObj.DiccionarioStrALista() == None:
#                            self.ErrorNumero = self.RespuestaObj.ErrorNumero
#                            self.ErrorDescripcion = self.RespuestaObj.ErrorDescripcion
#                        else:
#                            self.ErrorNumero = self.RespuestaObj.ErrorNumero
#                            self.ErrorDescripcion = self.RespuestaObj.ErrorDescripcion
#                            return self.RespuestaObj.DiccionarioStrALista()
#                    except:
#                        self.ErrorNumero = 1102
#                        self.ErrorDescripcion = 'Error 1102: Error en la convercion del diccionario'
#                        return self.RespuestaParseada
#            elif self.TipoRespuesta == 'XML':
#                return self.__RespuestaXML.TraerXML()
#            else:
#                return self.RespuestaParseada
#        except:
#            self.ErrorNumber = 1101
#            self.Err = 'Error 1101: Imposible leer %s de "%s"' % (self.NombreCampo, self.Metodo)
#            return None
        
    def Fields(self,campo):
        return self.__recordset.Fields(campo)
    def MoveNext(self):
        self.__recordset.MoveNext()
        
    def MoveLast(self):
        self.__recordset.MoveLast()
        
    def MovePrevious(self):
        self.__recordset.MovePrevious()
        
    def MoveFirst(self):
        self.__recordset.MoveFirst()
    def BOF(self):
        return self.__recordset.BOF()
    def EOF(self):
        return self.__recordset.EOF()
    def Count(self):
        return self.__recordset.Count()
    def GetRecordSet(self):
        return self.__recordset
    def GetDict(self):
        return self.__recordset.GetDict()
    def GetIndex(self):
        return self.__recordset.GetIndex()
    
    
        
        
        
class RecordSet():
    def __init__(self,diccionario = '{}'):
        query = 'self._record = ' + diccionario
        exec(query)
        if len(self._record) != 0:
            self._minindex = 1
            self._maxindex = len(self._record)
            self._recordcount = len(self._record)
            self._index = self._minindex
        else:
            self._minindex = -1
            self._maxindex = -1
            self._recordcount = 0
            self._index = -1
    def Fields(self,campo):
        respuesta = self._record[str(self.GetIndex())]
        aux = respuesta[str(campo)]
        return aux
    
    def BOF(self):
        if len(self._record) == 0:
            self._BOF = True
        else:
            self._BOF = False
            
        return self._BOF
    def EOF(self):
        if self._index > self._maxindex :
            return True
        else:
            return False
    def Count(self):
        return self._recordcount
    def MoveNext(self):
        self._index = self._index + 1
    def MovePrevious(self):
        if self._index > self._minindex:
            self._index = self._index - 1
        else:
            self._index = self._minindex
    def MoveLast(self):
        self._index = self._maxindex
    def MoveFirst(self):
        self._index = self._minindex
    def GetDict(self):
        return self._record.copy()   
    def GetIndex(self):
        return self._index
   
SALIDA_XML_STORED = 1
SALIDA_XML = 2 
class XmlStored():
    def __init__(self,Raiz):
            self.ErrorDescripcion = ""
            self.NroError = 0
            self.NameClase = "Xml"
            raiz = "<" + str(Raiz)+"></"+str(Raiz)+">"
            self._Xml = xml.dom.minidom.parseString(raiz)
            self.AddNodoHijo("ControlVacio", {})
    def AddNodoHijo(self,NombreNodo,DictNodos):
        element = self._Xml.createElement(NombreNodo)
        for key in DictNodos:
            subelement = self._Xml.createElement(DictNodos[key]["Name"])
            textElement = self._Xml.createTextNode(DictNodos[key]["Value"])
            subelement.appendChild(textElement)
            element.appendChild(subelement)
        self._Xml.childNodes[0].appendChild(element)
    def GetToXml(self,salida = SALIDA_XML_STORED):
        xmldoc = self._Xml.toxml("ISO-8859-1")
        if salida == SALIDA_XML_STORED:
            xmldoc = xmldoc.replace("&","&amp;").replace("<","&lt;")
            xmldoc = xmldoc.replace("\"","&quot;").replace(">","&gt;")
        return xmldoc
        
        
        
        

            
            


#******************************************************************************


#Ejemplo de muestra de como se usaria en codigo
##Password = 'nestor'
##UserName = 'nmedina'
##valor = {}
##Parametros = {1:('TipoRespuesta','Python')}
##Servicio = WebService(UrlServidor = "http://172.16.4.170/sistemastock/ServiceStock.asmx" ,Host = "172.16.4.170",UrlProxy = "http://nmedina:123456789@172.16.4.1:8080")
##if Servicio.Enviar("SELECT_DatosFijos_Fabricantes","www.osplad.org.ar",Parametros) == True:
##    cant = len(Servicio.LeerDatos('ID_Fabricante'))
##    print cant
##    for i in range(cant):
##        print i
##        j = i
##        valor[i] = {'id':Servicio.LeerDatos('ID_Fabricante')[i]}
##        valor[i] = {'Id_Fabricante': Servicio.LeerDatos('ID_Fabricante')[i]}
##            valor[i] = {'ID_Fabricante':WebService.LeerDatos('ID_Fabricante')[i]}
##                        'Nombre':WebService.LeerDatos('Nombre')[i],
##                        'Descripcion':WebService.LeerDatos('Descripcion')[i]}
##    print valor
##else:
##    print Servicio.ErrorDescripcion
